home *** CD-ROM | disk | FTP | other *** search
/ Micromanía 92 / CDMM92_1.ISO / SOF 2 SDK / sof2sdk-101.msi / _92D6AC311BB48EBA344BBABC89DA6AB0 / _3598A18C61A54EE988577D3D98363E6A < prev    next >
Encoding:
Text File  |  2002-06-19  |  51.0 KB  |  1,983 lines
  1. // Copyright (C) 2001-2002 Raven Software.
  2. //
  3. // cg_main.c -- initialization and primary entry point for cgame
  4.  
  5. #include "cg_local.h"
  6. #include "../ui/ui_shared.h"
  7.  
  8. // display context for new ui stuff
  9. displayContextDef_t cgDC;
  10.  
  11. #if !defined(CL_LIGHT_H_INC)
  12.     #include "cg_lights.h"
  13. #endif
  14.  
  15.  
  16. int forceModelModificationCount = -1;
  17.  
  18. void CG_Init        ( int serverMessageNum, int serverCommandSequence, int clientNum );
  19. void CG_InitItems    ( void );
  20. void CG_Shutdown    ( void );
  21.  
  22. void CG_CalcEntityLerpPositions( centity_t *cent );
  23.  
  24. static int    C_PointContents            (void);
  25. static void C_GetLerpOrigin            (void);
  26. static void C_GetLerpAngles            (void);
  27. static void C_GetModelScale            (void);
  28. static void C_Trace                    (void);
  29. static void C_CameraShake            (void);
  30.  
  31. /*
  32. ================
  33. vmMain
  34.  
  35. This is the only way control passes into the module.
  36. This must be the very first function compiled into the .q3vm file
  37. ================
  38. */
  39. int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) 
  40. {
  41.     switch ( command ) 
  42.     {
  43.         case CG_INIT:
  44.             CG_Init( arg0, arg1, arg2 );
  45.             return 0;
  46.  
  47.         case CG_SHUTDOWN:
  48.             CG_Shutdown();
  49.             return 0;
  50.  
  51.         case CG_CONSOLE_COMMAND:
  52.             return CG_ConsoleCommand();
  53.  
  54.         case CG_DRAW_ACTIVE_FRAME:
  55.             CG_DrawActiveFrame( arg0, arg1, arg2 );
  56.             return 0;
  57.  
  58.         case CG_CROSSHAIR_PLAYER:
  59.             return CG_CrosshairPlayer();
  60.         
  61.         case CG_LAST_ATTACKER:
  62.             return CG_LastAttacker();
  63.         
  64.         case CG_KEY_EVENT:
  65.             CG_KeyEvent(arg0, arg1);
  66.             return 0;
  67.  
  68.         case CG_MOUSE_EVENT:
  69.             cgDC.cursorx = cgs.cursorX;
  70.             cgDC.cursory = cgs.cursorY;
  71.             
  72.             CG_MouseEvent(arg0, arg1);
  73.             return 0;
  74.  
  75.         case CG_EVENT_HANDLING:
  76.             CG_EventHandling(arg0);
  77.             return 0;
  78.  
  79.         case CG_POINT_CONTENTS:
  80.             return C_PointContents();
  81.  
  82.         case CG_GET_LERP_ORIGIN:
  83.             C_GetLerpOrigin();
  84.             return 0;
  85.  
  86.         case CG_GET_LERP_ANGLES:
  87.             C_GetLerpAngles();
  88.             return 0;
  89.  
  90.         case CG_GET_MODEL_SCALE:
  91.             C_GetModelScale();
  92.             return 0;
  93.  
  94.         case CG_GET_GHOUL2:
  95.             return (int)CG_GetEntity (arg0)->ghoul2;
  96.  
  97.         case CG_GET_MODEL_LIST:
  98.             return (int)cgs.gameModels;
  99.  
  100.         case CG_CALC_LERP_POSITIONS:
  101.             CG_CalcEntityLerpPositions( CG_GetEntity ( arg0 ) );
  102.             return 0;
  103.  
  104.         case CG_TRACE:
  105.             C_Trace();
  106.             return 0;
  107.  
  108.         case CG_GET_ORIGIN:
  109.             VectorCopy( CG_GetEntity (arg0)->currentState.pos.trBase, (float *)arg1);
  110.             return 0;
  111.  
  112.         case CG_GET_ANGLES:
  113.             VectorCopy( CG_GetEntity (arg0)->currentState.apos.trBase, (float *)arg1);
  114.             return 0;
  115.  
  116.         case CG_GET_ORIGIN_TRAJECTORY:
  117.             return (int)&CG_GetEntity (arg0)->nextState.pos;
  118.  
  119.         case CG_GET_ANGLE_TRAJECTORY:
  120.             return (int)&CG_GetEntity (arg0)->nextState.apos;
  121.  
  122.         case CG_FX_CAMERASHAKE:
  123.             C_CameraShake();
  124.             return 0;
  125.  
  126.         case CG_MISC_ENT:
  127.             CG_MiscEnt();
  128.             return 0;
  129.  
  130.         case CG_MAP_CHANGE:
  131.             // this trap map be called more than once for a given map change, as the
  132.             // server is going to attempt to send out multiple broadcasts in hopes that
  133.             // the client will receive one of them
  134.             cg.mMapChange = qtrue;
  135.             trap_S_ClearLoopingSounds ( qtrue );
  136.             trap_S_StopAllSounds ( );
  137.             trap_UI_CloseAll ( );
  138.             return 0;
  139.  
  140.         case CG_VOICE_EVENT:
  141.             Com_Printf ( "voice:  event %d\n", arg0 );
  142.             switch ( arg0 )
  143.             {
  144.                 case VEV_TALKSTART:
  145.                     if ( arg1 != cg.predictedPlayerState.clientNum )
  146.                     {
  147.                         trap_S_StartLocalSound ( trap_S_RegisterSound ( "sound/radiostart.wav" ), CHAN_AUTO );
  148.                     }
  149.                     cgs.clientinfo[arg1].voice = qtrue;
  150.                     break;
  151.  
  152.                 case VEV_TALKSTOP:
  153.                     if ( arg1 != cg.predictedPlayerState.clientNum )
  154.                     {
  155.                         trap_S_StartLocalSound ( trap_S_RegisterSound ( "sound/radiostart.wav" ), CHAN_AUTO );
  156.                     }
  157.                     cgs.clientinfo[arg1].voice = qfalse;
  158.                     break;
  159.             }
  160.                     
  161.             return 0;
  162.  
  163.         default:
  164.             Com_Error( ERR_FATAL, "vmMain: unknown command %i", command );
  165.             break;
  166.     }
  167.  
  168.     return -1;
  169. }
  170.  
  171. static int C_PointContents(void)
  172. {
  173.     TCGPointContents    *data = (TCGPointContents *)cg.sharedBuffer;
  174.  
  175.     return CG_PointContents( data->mPoint, data->mPassEntityNum );
  176. }
  177.  
  178. static void C_GetLerpOrigin(void)
  179. {
  180.     TCGVectorData        *data = (TCGVectorData *)cg.sharedBuffer;
  181.  
  182.     VectorCopy( CG_GetEntity (data->mEntityNum)->lerpOrigin, data->mPoint);
  183. }
  184.  
  185. static void C_GetLerpAngles(void)
  186. {
  187.     TCGVectorData        *data = (TCGVectorData *)cg.sharedBuffer;
  188.  
  189.     VectorCopy(CG_GetEntity(data->mEntityNum)->lerpAngles, data->mPoint);
  190. }
  191.  
  192. static void C_GetModelScale(void)
  193. {
  194.     TCGVectorData        *data = (TCGVectorData *)cg.sharedBuffer;
  195.  
  196.     VectorCopy(CG_GetEntity(data->mEntityNum)->modelScale, data->mPoint);
  197. }
  198.  
  199. static void C_Trace(void)
  200. {
  201.     TCGTrace    *td = (TCGTrace *)cg.sharedBuffer;
  202.  
  203.     CG_Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
  204. }
  205.  
  206. static void C_CameraShake(void)
  207. {
  208.     TCGCameraShake    *data = (TCGCameraShake *)cg.sharedBuffer;
  209.  
  210.     CG_CameraShake ( data->mOrigin, data->mIntensity, data->mRadius, data->mTime );
  211. }
  212.  
  213. cg_t                cg;
  214. cgs_t                cgs;
  215. centity_t            cg_entities[MAX_GENTITIES];
  216. centity_t            *cg_permanents[MAX_GENTITIES];
  217. int                    cg_numpermanents = 0;
  218. weaponInfo_t        cg_weapons[MAX_WEAPONS];
  219. itemInfo_t            cg_items[MAX_ITEMS];
  220.  
  221. vmCvar_t    cg_centertime;
  222. vmCvar_t    cg_centerY;
  223. vmCvar_t    cg_runpitch;
  224. vmCvar_t    cg_runroll;
  225. vmCvar_t    cg_bobup;
  226. vmCvar_t    cg_bobpitch;
  227. vmCvar_t    cg_bobroll;
  228. vmCvar_t    cg_shadows;
  229. vmCvar_t    cg_drawTimer;
  230. vmCvar_t    cg_drawFPS;
  231. vmCvar_t    cg_drawSnapshot;
  232. vmCvar_t    cg_drawCrosshair;
  233. vmCvar_t    cg_drawCrosshairNames;
  234. vmCvar_t    cg_drawRadar;
  235. vmCvar_t    cg_drawTeamScores;
  236. vmCvar_t    cg_drawHUDIcons;
  237. vmCvar_t    cg_crosshairSize;
  238. vmCvar_t    cg_crosshairGrow;
  239. vmCvar_t    cg_crosshairX;
  240. vmCvar_t    cg_crosshairY;
  241. vmCvar_t    cg_crosshairRGBA;
  242. vmCvar_t    cg_crosshairFriendRGBA;
  243. vmCvar_t    cg_draw2D;
  244. vmCvar_t    cg_debugEvents;
  245. vmCvar_t    cg_errorDecay;
  246. vmCvar_t    cg_nopredict;
  247. vmCvar_t    cg_showmiss;
  248. vmCvar_t    cg_footsteps;
  249. vmCvar_t    cg_drawGun;
  250. vmCvar_t    cg_gun_x;
  251. vmCvar_t    cg_gun_y;
  252. vmCvar_t    cg_gun_z;
  253. vmCvar_t    cg_autoswitch;
  254. vmCvar_t    cg_ignore;
  255. vmCvar_t    cg_simpleItems;
  256. vmCvar_t    cg_fov;
  257. vmCvar_t    cg_goreDetail;
  258. vmCvar_t    cg_thirdPerson;
  259. vmCvar_t    cg_thirdPersonRange;
  260. vmCvar_t    cg_thirdPersonYaw;
  261. vmCvar_t    cg_thirdPersonPitch;
  262. vmCvar_t    cg_thirdPersonHorzOffset;
  263. vmCvar_t    cg_stereoSeparation;
  264. vmCvar_t    cg_lagometer;
  265. vmCvar_t    cg_synchronousClients;
  266. vmCvar_t     cg_chatTime;
  267. vmCvar_t     cg_chatHeight;
  268. vmCvar_t     cg_stats;
  269. vmCvar_t     cg_buildScript;
  270. vmCvar_t     cg_forceModel;
  271. vmCvar_t    cg_paused;
  272. vmCvar_t    cg_predictItems;
  273. vmCvar_t    cg_antiLag;
  274. vmCvar_t    cg_impactPrediction;
  275. vmCvar_t    cg_autoReload;
  276. vmCvar_t    cg_deferPlayers;
  277. vmCvar_t    cg_drawFriend;
  278. vmCvar_t    cg_teamChatsOnly;
  279. vmCvar_t    cg_noVoiceText;
  280. vmCvar_t    cg_hudFiles;
  281. vmCvar_t     cg_smoothClients;
  282. vmCvar_t    pmove_fixed;
  283. vmCvar_t    pmove_msec;
  284. vmCvar_t    cg_pmove_msec;
  285. vmCvar_t    cg_cameraMode;
  286. vmCvar_t    cg_cameraOrbit;
  287. vmCvar_t    cg_cameraOrbitDelay;
  288. vmCvar_t    cg_timescale;
  289. vmCvar_t    cg_noProjectileTrail;
  290. vmCvar_t    cg_currentSelectedPlayer;
  291. vmCvar_t    cg_currentSelectedPlayerName;
  292. vmCvar_t    cg_DebugGore;
  293. vmCvar_t    cg_lockBlood;
  294. vmCvar_t    cg_lockSever;
  295. vmCvar_t    cg_lockDeaths;
  296. vmCvar_t    cg_marks;
  297. vmCvar_t    cg_shellEjection;
  298. vmCvar_t    RMG_distancecull;
  299.  
  300. vmCvar_t    cg_blueteamname;
  301. vmCvar_t    cg_redteamname;
  302.  
  303. vmCvar_t    cg_damageindicator;
  304. vmCvar_t    cg_tracerChance;
  305. vmCvar_t    cg_animBlend;
  306.  
  307. vmCvar_t    cg_automap_x;
  308. vmCvar_t    cg_automap_y;
  309. vmCvar_t    cg_automap_w;
  310. vmCvar_t    cg_automap_h;
  311. vmCvar_t    cg_automap_a;
  312.  
  313. vmCvar_t    ui_info_redcount;
  314. vmCvar_t    ui_info_bluecount;
  315. vmCvar_t    ui_info_speccount;
  316. vmCvar_t    ui_info_freecount;
  317. vmCvar_t    ui_info_pickupsdisabled;
  318. vmCvar_t    ui_info_seenobjectives;
  319.  
  320. vmCvar_t    cg_voiceRadio;
  321. vmCvar_t    cg_voiceGlobal;
  322. vmCvar_t    cg_soundGlobal;
  323. vmCvar_t    cg_soundFrag;
  324.  
  325. vmCvar_t    cg_weaponMenuFast;
  326.  
  327. vmCvar_t    cg_bodyTime;
  328.  
  329. vmCvar_t    cg_zoomWeaponChange;
  330.  
  331. vmCvar_t    rw_enabled;
  332.  
  333. typedef struct 
  334. {
  335.     vmCvar_t    *vmCvar;
  336.     char        *cvarName;
  337.     char        *defaultString;
  338.     int            cvarFlags;
  339.     float        mMinValue, mMaxValue;
  340. } cvarTable_t;
  341.  
  342. static cvarTable_t cvarTable[] = 
  343. { 
  344.     { &cg_lockBlood, "lock_blood", "1", 0 },
  345.     { &cg_lockSever, "lock_sever", "1", 0 },
  346.     { &cg_lockDeaths, "lock_deaths", "1", 0 },
  347.     { &rw_enabled,      "rw_enabled",    "0", 0 },
  348.  
  349.     { &cg_shellEjection, "cg_shellEjection", "1", CVAR_ARCHIVE },
  350.     { &cg_ignore, "cg_ignore", "0", 0 },
  351.     { &cg_autoswitch, "cg_autoswitch", "2", CVAR_ARCHIVE },
  352.     { &cg_drawGun, "cg_drawGun", "1", CVAR_ARCHIVE },
  353.     { &cg_fov, "cg_fov", "80", CVAR_ARCHIVE | CVAR_LOCK_RANGE, 80.0, 100.0 },
  354.     { &cg_stereoSeparation, "cg_stereoSeparation", "0.4", CVAR_ARCHIVE  },
  355.     { &cg_shadows, "cg_shadows", "1", CVAR_ARCHIVE  },
  356.     { &cg_draw2D, "cg_draw2D", "1", CVAR_ARCHIVE|CVAR_CHEAT  },
  357.     { &cg_drawTimer, "cg_drawTimer", "1", CVAR_ARCHIVE  },
  358.     { &cg_drawFPS, "cg_drawFPS", "0", CVAR_ARCHIVE  },
  359.     { &cg_drawSnapshot, "cg_drawSnapshot", "0", CVAR_ARCHIVE  },
  360.     { &cg_drawCrosshair, "cg_drawCrosshair", "4", CVAR_ARCHIVE },
  361.     { &cg_drawCrosshairNames, "cg_drawCrosshairNames", "1", CVAR_ARCHIVE },
  362.     { &cg_drawHUDIcons,    "cg_drawHUDIcons",    "1", CVAR_ARCHIVE },
  363.     { &cg_crosshairSize, "cg_crosshairSize", "24", CVAR_ARCHIVE },
  364.     { &cg_crosshairGrow, "cg_crosshairGrow", "1", CVAR_ARCHIVE },
  365.     { &cg_crosshairX, "cg_crosshairX", "0", CVAR_ARCHIVE },
  366.     { &cg_crosshairY, "cg_crosshairY", "0", CVAR_ARCHIVE },
  367.     { &cg_crosshairRGBA, "cg_crosshairRGBA", "1,1,1,1", CVAR_ARCHIVE },
  368.     { &cg_crosshairFriendRGBA, "cg_crosshairFriendRGBA", "1,0,0,1", CVAR_ARCHIVE },
  369.     { &cg_simpleItems, "cg_simpleItems", "0", CVAR_ARCHIVE },
  370.     { &cg_lagometer, "cg_lagometer", "0", CVAR_ARCHIVE },
  371.     { &cg_gun_x, "cg_gunX", "0", CVAR_CHEAT },
  372.     { &cg_gun_y, "cg_gunY", "0", CVAR_CHEAT },
  373.     { &cg_gun_z, "cg_gunZ", "0", CVAR_CHEAT },
  374.     { &cg_centertime, "cg_centertime", "4", CVAR_ARCHIVE },
  375.     { &cg_centerY,      "cg_centerY",  "70", CVAR_ARCHIVE },
  376.     { &cg_runpitch, "cg_runpitch", "0.002", CVAR_ARCHIVE|CVAR_LOCK_RANGE, 0.0f, 0.002f },
  377.     { &cg_runroll, "cg_runroll", "0.005", CVAR_ARCHIVE|CVAR_LOCK_RANGE, 0.0f, 0.005f },
  378.     { &cg_bobup , "cg_bobup", "0.005", CVAR_ARCHIVE|CVAR_LOCK_RANGE, 0.0f, 0.005f },
  379.     { &cg_bobpitch, "cg_bobpitch", "0.001", CVAR_ARCHIVE|CVAR_LOCK_RANGE, 0.0f, 0.001f },
  380.     { &cg_bobroll, "cg_bobroll", "0.001", CVAR_ARCHIVE|CVAR_LOCK_RANGE, 0.0f, 0.001f },
  381.     { &cg_debugEvents, "cg_debugevents", "0", CVAR_CHEAT },
  382.     { &cg_errorDecay, "cg_errordecay", "100", 0 },
  383.     { &cg_nopredict, "cg_nopredict", "0", 0 },
  384.     { &cg_showmiss, "cg_showmiss", "0", 0 },
  385.     { &cg_footsteps, "cg_footsteps", "1", CVAR_CHEAT },
  386.  
  387.     { &cg_goreDetail, "cg_goreDetail", "1", CVAR_ARCHIVE },
  388.  
  389.     { &cg_thirdPerson, "cg_thirdPerson", "0", CVAR_CHEAT },
  390.     { &cg_thirdPersonRange, "cg_thirdPersonRange", "80", CVAR_CHEAT },
  391.     { &cg_thirdPersonYaw, "cg_thirdPersonYaw", "0", CVAR_CHEAT },
  392.     { &cg_thirdPersonPitch, "cg_thirdPersonPitch", "15", CVAR_CHEAT },
  393.     
  394.     { &cg_thirdPersonHorzOffset, "cg_thirdPersonHorzOffset", "0", CVAR_CHEAT },
  395.  
  396.     { &cg_chatTime, "cg_chatTime", "8000", CVAR_ARCHIVE  },
  397.     { &cg_chatHeight, "cg_chatHeight", "4", CVAR_ARCHIVE  },
  398.     { &cg_forceModel, "cg_forceModel", "0", CVAR_ARCHIVE  },
  399.     { &cg_predictItems, "cg_predictItems", "1", CVAR_ARCHIVE },
  400.     { &cg_antiLag, "cg_antiLag", "1", CVAR_ARCHIVE | CVAR_USERINFO },
  401. #ifdef _SOF2_FLESHIMPACTPREDICTION
  402.     { &cg_impactPrediction, "cg_impactPrediction", "2", CVAR_ARCHIVE },
  403. #else
  404.     { &cg_impactPrediction, "cg_impactPrediction", "1", CVAR_ARCHIVE },
  405. #endif
  406.     { &cg_autoReload, "cg_autoReload", "1", CVAR_ARCHIVE | CVAR_USERINFO },
  407.     { &cg_deferPlayers, "cg_deferPlayers", "1", CVAR_ARCHIVE },
  408.     { &cg_stats, "cg_stats", "0", 0 },
  409.     { &cg_drawFriend, "cg_drawFriend", "1", CVAR_ARCHIVE },
  410.     { &cg_teamChatsOnly, "cg_teamChatsOnly", "0", CVAR_ARCHIVE },
  411.     { &cg_noVoiceText, "cg_noVoiceText", "0", CVAR_ARCHIVE },
  412.     // the following variables are created in other parts of the system,
  413.     // but we also reference them here
  414.     { &cg_buildScript, "com_buildScript", "0", 0 },    // force loading of all possible data amd error on failures
  415.     { &cg_paused, "cl_paused", "0", CVAR_ROM },
  416.     { &cg_synchronousClients, "g_synchronousClients", "0", 0 },    // communicated by systeminfo
  417.  
  418.     { &cg_currentSelectedPlayer, "cg_currentSelectedPlayer", "0", CVAR_ARCHIVE},
  419.     { &cg_currentSelectedPlayerName, "cg_currentSelectedPlayerName", "", CVAR_ARCHIVE},
  420.     { &cg_hudFiles, "cg_hudFiles", "ui/hud.txt", CVAR_ARCHIVE},
  421.  
  422.     { &cg_cameraOrbit, "cg_cameraOrbit", "0", CVAR_CHEAT},
  423.     { &cg_cameraOrbitDelay, "cg_cameraOrbitDelay", "50", CVAR_ARCHIVE},
  424.     { &cg_timescale, "timescale", "1", 0},
  425.     { &cg_smoothClients, "cg_smoothClients", "0", CVAR_USERINFO | CVAR_ARCHIVE},
  426.     { &cg_cameraMode, "com_cameraMode", "0", CVAR_CHEAT},
  427.  
  428.     { &pmove_fixed, "pmove_fixed", "0", 0},
  429.     { &pmove_msec, "pmove_msec", "8", 0},
  430.     { &cg_noProjectileTrail, "cg_noProjectileTrail", "0", CVAR_ARCHIVE},
  431.  
  432.     { &cg_DebugGore, "cg_debuggore", "", CVAR_CHEAT },
  433.     { &RMG_distancecull, "RMG_distancecull", "5000", CVAR_CHEAT },
  434.  
  435.     { &cg_blueteamname, "ui_blueteamname", "0", CVAR_ROM|CVAR_INTERNAL },
  436.     { &cg_redteamname, "ui_redteamname", "0", CVAR_ROM|CVAR_INTERNAL },
  437.  
  438.     { &cg_damageindicator, "cg_damageindicator", "1.5", CVAR_ARCHIVE },
  439.     { &cg_tracerChance,       "cg_tracerChance", "1", CVAR_ARCHIVE | CVAR_LOCK_RANGE, 0.0f, 0.50f },
  440.  
  441.     { &cg_animBlend, "cg_animBlend", "1", CVAR_ARCHIVE },
  442.  
  443.     { &cg_automap_x, "cg_automap_x", "485", CVAR_ARCHIVE | CVAR_LOCK_RANGE, 0.0, 629.0 },
  444.     { &cg_automap_y, "cg_automap_y", "5", CVAR_ARCHIVE  | CVAR_LOCK_RANGE, 0.0, 469.0},
  445.     { &cg_automap_w, "cg_automap_w", "150", CVAR_ARCHIVE | CVAR_LOCK_RANGE, 10.0, 640.0 },
  446.     { &cg_automap_h, "cg_automap_h", "150", CVAR_ARCHIVE | CVAR_LOCK_RANGE, 10.0, 480.0},
  447.     { &cg_automap_a, "cg_automap_a", "0.75", CVAR_ARCHIVE | CVAR_LOCK_RANGE, 0.0, 1.0},
  448.  
  449.     { &cg_drawRadar, "cg_drawRadar", "2", CVAR_ARCHIVE },
  450.     { &cg_drawTeamScores, "cg_drawTeamScores", "1", CVAR_ARCHIVE },
  451.  
  452.     { &ui_info_redcount, "ui_info_redcount", "0", CVAR_INTERNAL|CVAR_ROM },
  453.     { &ui_info_bluecount, "ui_info_bluecount", "0", CVAR_INTERNAL|CVAR_ROM },
  454.     { &ui_info_speccount, "ui_info_speccount", "0", CVAR_INTERNAL|CVAR_ROM },
  455.     { &ui_info_freecount, "ui_info_freecount", "0", CVAR_INTERNAL|CVAR_ROM },
  456.     { &ui_info_pickupsdisabled, "ui_info_pickupsdisabled", "0", CVAR_INTERNAL|CVAR_ROM },
  457.     { &ui_info_seenobjectives, "ui_info_seenobjectives", "0", CVAR_INTERNAL|CVAR_ROM },
  458.  
  459.     { &cg_voiceRadio,    "cg_voiceRadio",    "1",    CVAR_ARCHIVE,    0.0f,    0.0f },
  460.     { &cg_voiceGlobal,    "cg_voiceGlobal",    "1",    CVAR_ARCHIVE,    0.0f,    0.0f },
  461.     { &cg_soundGlobal,    "cg_soundGlobal",    "1",    CVAR_ARCHIVE,    0.0f,    0.0f },
  462.     { &cg_soundFrag,    "cg_soundFrag",        "1",    CVAR_ARCHIVE,    0.0f,    0.0f },
  463.     
  464.     { &cg_weaponMenuFast,  "cg_weaponMenuFast", "0", CVAR_ARCHIVE },
  465.  
  466.     { &cg_bodyTime,        "cg_bodyTime",            "0",    CVAR_ARCHIVE,    0.0f, 0.0f },
  467.  
  468.     { &cg_zoomWeaponChange,    "cg_zoomWeaponChange", "1", CVAR_ARCHIVE, 0.0f, 0.0f },
  469. };
  470.  
  471. static int  cvarTableSize = sizeof( cvarTable ) / sizeof( cvarTable[0] );
  472.  
  473. /*
  474. =================
  475. CG_RegisterCvars
  476. =================
  477. */
  478. void CG_RegisterCvars( void ) 
  479. {
  480.     int            i;
  481.     cvarTable_t    *cv;
  482.     char        var[MAX_TOKEN_CHARS];
  483.  
  484.     for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) 
  485.     {
  486.         trap_Cvar_Register( cv->vmCvar, cv->cvarName, cv->defaultString, cv->cvarFlags, cv->mMinValue, cv->mMaxValue );
  487.     }
  488.  
  489.     // see if we are also running the server on this machine
  490.     trap_Cvar_VariableStringBuffer( "sv_running", var, sizeof( var ) );
  491.     cgs.localServer = atoi( var );
  492.  
  493.     forceModelModificationCount = cg_forceModel.modificationCount;
  494.  
  495.     trap_Cvar_Register(NULL, "identity",        DEFAULT_IDENTITY, CVAR_USERINFO | CVAR_ARCHIVE, 0.0, 0.0 );
  496.     trap_Cvar_Register(NULL, "team_identity",    DEFAULT_IDENTITY, CVAR_USERINFO | CVAR_ARCHIVE, 0.0, 0.0 );
  497.     trap_Cvar_Register(NULL, "outfitting",        "AAAA",              CVAR_USERINFO | CVAR_ARCHIVE, 0.0, 0.0 );
  498.  
  499.     // Cvars uses for transferring data between client and server
  500.     trap_Cvar_Register(NULL, "ui_about_gametype",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  501.     trap_Cvar_Register(NULL, "ui_about_gametypename",    "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  502.     trap_Cvar_Register(NULL, "ui_about_scorelimit",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  503.     trap_Cvar_Register(NULL, "ui_about_timelimit",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  504.     trap_Cvar_Register(NULL, "ui_about_maxclients",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  505.     trap_Cvar_Register(NULL, "ui_about_dmflags",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  506.     trap_Cvar_Register(NULL, "ui_about_mapname",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  507.     trap_Cvar_Register(NULL, "ui_about_hostname",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  508.     trap_Cvar_Register(NULL, "ui_about_needpass",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  509.     trap_Cvar_Register(NULL, "ui_about_botminplayers",    "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  510.     trap_Cvar_Register(NULL, "ui_info_availableweapons","0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  511.  
  512.     trap_Cvar_Register(NULL, "ui_info_redscore",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  513.     trap_Cvar_Register(NULL, "ui_info_bluescore",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  514.  
  515.     trap_Cvar_Register(NULL, "cg_lastobjectives",        "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  516.  
  517.     trap_Cvar_Register(NULL, "ui_about_seed",            "0", CVAR_ROM|CVAR_INTERNAL, 0.0, 0.0 );
  518.  
  519.     trap_Cvar_Set ( "ui_info_seenobjectives", "0" );
  520.     trap_Cvar_Set ( "ui_info_redscore", "0" );
  521.     trap_Cvar_Set ( "ui_info_bluescore", "0" );
  522. }
  523.  
  524. /*                                                                                                                                            
  525. ===================
  526. CG_ForceModelChange
  527. ===================
  528. */
  529. static void CG_ForceModelChange( void ) 
  530. {
  531.     int        i;
  532.  
  533.     for (i=0 ; i<MAX_CLIENTS ; i++) 
  534.     {
  535.         const char        *clientInfo;
  536.  
  537.         clientInfo = CG_ConfigString( CS_PLAYERS+i );
  538.         if ( !clientInfo[0] ) 
  539.         {
  540.             continue;
  541.         }
  542.  
  543.         CG_NewClientInfo( i );
  544.     }
  545. }
  546.  
  547. /*
  548. ==================
  549. CG_UpdateTeamCountCvars
  550. ==================
  551. */
  552. void CG_UpdateTeamCountCvars ( void )
  553. {
  554.     int i;
  555.     int counts[TEAM_NUM_TEAMS];
  556.  
  557.     memset ( counts, 0, sizeof(counts) );
  558.  
  559.     for ( i = 0 ; i < cgs.maxclients ; i++ ) 
  560.     {
  561.         clientInfo_t* cl;
  562.         
  563.         cl = &cgs.clientinfo[ i ];
  564.  
  565.         if ( !cl->infoValid )
  566.         {
  567.             continue;
  568.         }
  569.         
  570.         counts[cl->team]++;
  571.     }
  572.  
  573.     trap_Cvar_Set ( "ui_info_redcount",  va("%i", counts[TEAM_RED] ) );
  574.     trap_Cvar_Set ( "ui_info_bluecount", va("%i", counts[TEAM_BLUE]) );
  575.     trap_Cvar_Set ( "ui_info_freecount", va("%i", counts[TEAM_FREE]) );
  576.     trap_Cvar_Set ( "ui_info_speccount", va("%i", counts[TEAM_SPECTATOR] ) );
  577. }
  578.  
  579. /*
  580. =================
  581. CG_UpdateCvars
  582. =================
  583. */
  584. void CG_UpdateCvars( void ) 
  585. {
  586.     int            i;
  587.     cvarTable_t    *cv;
  588.  
  589.     static int crosshairRGBAModificationCount = -1;
  590.     static int crosshairFriendRGBAModificationCount = -1;
  591.  
  592.     for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) 
  593.     {
  594.         trap_Cvar_Update( cv->vmCvar );
  595.     }
  596.  
  597.     // if force model changed
  598.     if ( forceModelModificationCount != cg_forceModel.modificationCount ) 
  599.     {
  600.         forceModelModificationCount = cg_forceModel.modificationCount;
  601.         CG_ForceModelChange();
  602.     }
  603.  
  604.     // If the crosshair RGBA was modified then update the globals
  605.     if ( crosshairRGBAModificationCount != cg_crosshairRGBA.modificationCount )
  606.     {
  607.         sscanf ( cg_crosshairRGBA.string, "%f,%f,%f,%f", 
  608.                  &cg.crosshairRGBA[0],
  609.                  &cg.crosshairRGBA[1],
  610.                  &cg.crosshairRGBA[2],
  611.                  &cg.crosshairRGBA[3] );
  612.  
  613.         crosshairRGBAModificationCount = cg_crosshairRGBA.modificationCount;
  614.     }
  615.  
  616.     // If the crosshair RGBA was modified then update the globals
  617.     if ( crosshairFriendRGBAModificationCount != cg_crosshairFriendRGBA.modificationCount )
  618.     {
  619.         sscanf ( cg_crosshairFriendRGBA.string, "%f,%f,%f,%f", 
  620.                  &cg.crosshairFriendRGBA[0],
  621.                  &cg.crosshairFriendRGBA[1],
  622.                  &cg.crosshairFriendRGBA[2],
  623.                  &cg.crosshairFriendRGBA[3] );
  624.  
  625.         crosshairFriendRGBAModificationCount = cg_crosshairFriendRGBA.modificationCount;
  626.     }
  627. }
  628.  
  629. int CG_CrosshairPlayer( void ) 
  630. {
  631.     if ( cg.time > ( cg.crosshairClientTime + 1000 ) ) 
  632.     {
  633.         return -1;
  634.     }
  635.     return cg.crosshairClientNum;
  636. }
  637.  
  638. int CG_LastAttacker( void ) {
  639.     if ( !cg.attackerTime ) {
  640.         return -1;
  641.     }
  642.     return cg.snap->ps.persistant[PERS_ATTACKER];
  643. }
  644.  
  645. #ifndef CGAME_HARD_LINKED
  646. // this is only here so the functions in q_shared.c and bg_*.c can link (FIXME)
  647.  
  648. void QDECL Com_Error( int level, const char *msg, ... ) 
  649. {
  650.     va_list        argptr;
  651.     char        text[1024];
  652.  
  653.     va_start (argptr, msg);
  654.     vsprintf (text, msg, argptr);
  655.     va_end (argptr);
  656.  
  657.     trap_Error( text );
  658. }
  659.  
  660. void QDECL Com_Printf( const char *msg, ... ) 
  661. {
  662.     va_list        argptr;
  663.     char        text[1024];
  664.  
  665.     va_start (argptr, msg);
  666.     vsprintf (text, msg, argptr);
  667.     va_end (argptr);
  668.  
  669.     trap_Print( text );
  670. }
  671.  
  672. #endif
  673.  
  674. /*
  675. =================
  676. CG_GetEntity
  677.  
  678. This function handles the predicted player entitiy specially.  The player
  679. should always be using the predicted entity rather than whats in the main 
  680. entity array.
  681. =================
  682. */
  683. centity_t* CG_GetEntity ( int index )
  684. {
  685. /*
  686.     if ( index == cg.clientNum )
  687.     {
  688.         return &cg.predictedPlayerEntity;
  689.     }
  690. */
  691.  
  692.     return &cg_entities[index];
  693. }
  694.  
  695. /*
  696. ================
  697. CG_Argv
  698. ================
  699. */
  700. const char *CG_Argv( int arg ) {
  701.     static char    buffer[MAX_STRING_CHARS];
  702.  
  703.     trap_Argv( arg, buffer, sizeof( buffer ) );
  704.  
  705.     return buffer;
  706. }
  707.  
  708.  
  709. //========================================================================
  710.  
  711. /*
  712. =================
  713. CG_RegisterItemSounds
  714.  
  715. The server says this item is used on this level
  716. =================
  717. */
  718. static void CG_RegisterItemSounds( int itemNum ) {
  719.     gitem_t            *item;
  720.     char            data[MAX_QPATH];
  721.     char            *s, *start;
  722.     int                len;
  723.  
  724.     item = &bg_itemlist[ itemNum ];
  725.  
  726.     if( item->pickup_sound ) {
  727.         trap_S_RegisterSound( item->pickup_sound );
  728.     }
  729.  
  730.     // parse the space seperated precache string for other media
  731.     s = item->sounds;
  732.     if (!s || !s[0])
  733.     {
  734.         return;
  735.     }
  736.  
  737.     while (*s) {
  738.         start = s;
  739.         while (*s && *s != ' ') 
  740.         {
  741.             s++;
  742.         }
  743.  
  744.         len = s-start;
  745.         if (len >= MAX_QPATH || len < 5) 
  746.         {
  747.             Com_Error( ERR_FATAL, "PrecacheItem: %s has bad precache string", item->classname);
  748.             return;
  749.         }
  750.         memcpy (data, start, len);
  751.         data[len] = 0;
  752.         if ( *s ) 
  753.         {
  754.             s++;
  755.         }
  756.  
  757.         if ( !strcmp(data+len-3, "wav" )) 
  758.         {
  759.             trap_S_RegisterSound( data );
  760.         }
  761.     }
  762. }
  763.  
  764. /*
  765. =================
  766. CG_RegisterLadders
  767.  
  768. Registers all the ladders in the current map
  769. =================
  770. */
  771. static void CG_RegisterLadders ( void )
  772. {
  773.     int            i;
  774.     const char    *ladder;
  775.  
  776.     for ( i = 0 ; i < MAX_LADDERS ; i++ ) 
  777.     {
  778.         vec3_t absmin;
  779.         vec3_t absmax;
  780.         vec3_t fwd;
  781.         vec3_t angles;
  782.  
  783.         ladder = CG_ConfigString( CS_LADDERS + i );
  784.         
  785.         // No ladder?    
  786.         if ( !ladder || !ladder[0] )
  787.         {
  788.             continue;
  789.         }
  790.  
  791.         VectorClear ( angles );
  792.         sscanf ( ladder, "%f,%f,%f,%f,%f,%f,%f",
  793.                  &absmin[0], &absmin[1], &absmin[2],
  794.                  &absmax[0], &absmax[1], &absmax[2],
  795.                  &angles[YAW] );
  796.  
  797.         AngleVectors( angles, fwd, 0, 0);
  798.  
  799.         BG_AddLadder ( absmin, absmax, fwd );
  800.     }
  801. }
  802.  
  803. /*
  804. =================
  805. CG_RegisterSounds
  806.  
  807. called during a precache command
  808. =================
  809. */
  810. static void CG_RegisterSounds( void ) 
  811. {
  812.     int        i;
  813.     char    items[MAX_ITEMS+1];
  814.     const char    *soundName;
  815.  
  816.     // voice commands
  817.     CG_LoadVoiceChats();
  818.  
  819.     CG_LoadingStage ( 3 );
  820.  
  821.     cgs.media.talkSound = trap_S_RegisterSound( "sound/player/talk.wav" );
  822.  
  823.     cgs.media.waterFootstep[0] = trap_S_RegisterSound( "sound/player/steps/water/water_step0");    
  824.     cgs.media.waterFootstep[1] = trap_S_RegisterSound( "sound/player/steps/water/water_step1");    
  825.  
  826.     cgs.media.waterWade[0] = trap_S_RegisterSound( "sound/player/steps/water/water_wade0");    
  827.     cgs.media.waterWade[1] = trap_S_RegisterSound( "sound/player/steps/water/water_wade1");    
  828.  
  829.     cgs.media.waterJumpIn    = trap_S_RegisterSound( "sound/player/jumps/water_jump");    
  830.     cgs.media.waterLeave    = trap_S_RegisterSound( "sound/pain_death/mullins/water_surface");    
  831.  
  832.     cgs.media.armorHitSound[0] = trap_S_RegisterSound( "sound/pain_death/mullins/armor01");    
  833.     cgs.media.armorHitSound[1] = trap_S_RegisterSound( "sound/pain_death/mullins/armor02");    
  834.     cgs.media.fleshHitSound[0] = trap_S_RegisterSound( "sound/pain_death/mullins/hit01");    
  835.     cgs.media.fleshHitSound[1] = trap_S_RegisterSound( "sound/pain_death/mullins/hit02");    
  836.  
  837.     // only register the items that the server says we need
  838.     strcpy( items, CG_ConfigString( CS_ITEMS ) );
  839.  
  840.     CG_LoadingStage ( 4 );
  841.  
  842.     for (i = 0; i < MAX_AMBIENT_SOUNDSETS; i++)    // 0 is reserved for current
  843.     {
  844.         const char *psString = CG_ConfigString( CS_AMBIENT_SOUNDSETS + i);            
  845.  
  846.         if (psString && strlen(psString))
  847.         {
  848.             trap_AS_AddPrecacheEntry( psString );
  849.         }
  850.         else
  851.         {
  852. //            break;    // EOL
  853.         }
  854.     }
  855.  
  856.     trap_AS_ParseSets();
  857.  
  858.     for ( i = 1 ; i < bg_numItems ; i++ ) 
  859.     {
  860.         CG_RegisterItemSounds( i );
  861.     }
  862.  
  863.     for ( i = 1 ; i < MAX_SOUNDS ; i++ ) 
  864.     {
  865.         soundName = CG_ConfigString( CS_SOUNDS+i );
  866.         
  867.         if ( !soundName[0] ) 
  868.         {
  869.             break;
  870.         }
  871.         
  872.         // custom sound
  873.         if ( soundName[0] == '*' ) 
  874.         {
  875.             continue;    
  876.         }
  877.  
  878.         cgs.gameSounds[i] = trap_S_RegisterSound( soundName );
  879.     }
  880.  
  881.  
  882.     cgs.media.glassBreakSound = trap_S_RegisterSound("sound/effects/glassbreak1.wav");
  883.  
  884.     // Respawn sound is only used in gametypes where you respawn
  885.     if ( cgs.gametypeData->respawnType != RT_NONE )
  886.     {
  887.         cgs.media.respawnSound = trap_S_RegisterSound("sound/player_respawn.wav");
  888.     }
  889.  
  890.     cgs.media.itemRespawnSound = trap_S_RegisterSound ( "sound/item_respawn.mp3" );
  891.  
  892.     cgs.media.fragSound       = trap_S_RegisterSound ( "sound/frag.mp3" );
  893.     cgs.media.fragSelfSound   = trap_S_RegisterSound ( "sound/self_frag.mp3" );
  894.     cgs.media.zoomSound       = trap_S_RegisterSound ( "sound/weapons/sniper/scope_zoom.wav" );
  895.     cgs.media.gogglesOnSound  = trap_S_RegisterSound ( "sound/weapons/goggles/turn_on.mp3" );
  896.     cgs.media.gogglesOffSound = trap_S_RegisterSound ( "sound/weapons/goggles/turn_off.mp3" );
  897.  
  898.     // Move out sound
  899.     if ( cgs.gametypeData->respawnType == RT_NONE )
  900.     {
  901.         cgs.media.goSound = trap_S_RegisterSound ( "sound/radio/male/move.mp3" );
  902.     }
  903.  
  904.     // bullet flyby sounds
  905.     for (i = 0; i < NUMFLYBYS; i++)
  906.     {
  907.         cgs.media.flybySounds[i] = trap_S_RegisterSound ( va("sound/player/bullet_impacts/whine/b_whine%d", i));
  908.     }
  909.  
  910.     // Water sounds
  911.     cgs.media.drownPainSound[0] = trap_S_RegisterSound ( "sound/pain_death/mullins/drown01.mp3" );
  912.     cgs.media.drownPainSound[1] = trap_S_RegisterSound ( "sound/pain_death/mullins/drown02.mp3" );
  913.     cgs.media.drownDeathSound   = trap_S_RegisterSound ( "sound/pain_death/mullins/drown_dead.mp3" );
  914.  
  915.     CG_LoadingStage ( 5 );
  916. }
  917.  
  918.  
  919. //-------------------------------------
  920. // CG_RegisterEffects
  921. // 
  922. // Handles precaching all effect files
  923. //    and any shader, model, or sound
  924. //    files an effect may use.
  925. //-------------------------------------
  926. static void CG_RegisterEffects( void )
  927. {
  928.     const char    *effectName;
  929.     int            i;
  930.  
  931.     for ( i = 1 ; i < MAX_FX ; i++ ) 
  932.     {
  933.         effectName = CG_ConfigString( CS_EFFECTS + i );
  934.  
  935.         if ( !effectName[0] ) 
  936.         {
  937.             break;
  938.         }
  939.  
  940.         trap_FX_RegisterEffect( effectName );
  941.     }
  942. }
  943.  
  944. //===================================================================================
  945.  
  946.  
  947. /*
  948. =================
  949. CG_RegisterGraphics
  950.  
  951. This function may execute for a couple of minutes with a slow disk.
  952. =================
  953. */
  954. static void CG_RegisterGraphics( void ) 
  955. {
  956.     int            i;
  957.     char        items[MAX_ITEMS+1];
  958.     int            sub;
  959.     char        temp[MAX_QPATH];
  960.     int            breakPoint;
  961.     const char    *terrainInfo;
  962.     int            terrainID;
  963.     vec3_t        distance;
  964.  
  965.     // clear any references to old media
  966.     memset( &cg.refdef, 0, sizeof( cg.refdef ) );
  967.     trap_R_ClearScene();
  968.  
  969.     // Load the map
  970.     CG_LoadingString( cgs.mapname );
  971.  
  972.     trap_R_LoadWorldMap( cgs.mapname );
  973.  
  974.     // precache status bar pics
  975.     CG_LoadingString( "game media" );
  976.  
  977.     CG_LoadingStage ( 6 );
  978.  
  979.     cgs.media.cursor = trap_R_RegisterShaderNoMip( "gfx/menus/cursor/cursor" );
  980.  
  981.     // Register the graphics for the scoreboard
  982.     cgs.media.scoreboard       = trap_R_RegisterShaderNoMip ( "gfx/menus/scoreboard/scoreboard.tga" );
  983.     cgs.media.scoreboardHeader = trap_R_RegisterShaderNoMip ( "gfx/menus/scoreboard/scorelineheader.tga" );
  984.     cgs.media.scoreboardLine   = trap_R_RegisterShaderNoMip ( "gfx/menus/scoreboard/scoreline.tga" );
  985.     cgs.media.scoreboardFooter = trap_R_RegisterShaderNoMip ( "gfx/menus/scoreboard/scorelinefooter.tga" );
  986.     cgs.media.scoreboardTotals = trap_R_RegisterShaderNoMip ( "gfx/menus/scoreboard/scorelinetotals.tga" );
  987.  
  988.     cgs.media.smokePuffShader = trap_R_RegisterShader( "smokePuff" );
  989.     cgs.media.lagometerShader = trap_R_RegisterShader("gfx/menus/hud/lagometer.tga" );
  990.     cgs.media.disconnectShader = trap_R_RegisterShader("gfx/menus/hud/disconnect.tga" );
  991.     cgs.media.waterBubbleShader = trap_R_RegisterShader( "gfx/misc/bubble" );
  992.     cgs.media.backTileShader = trap_R_RegisterShader( "gfx/2d/backtile" );
  993.  
  994.     cgs.media.mAutomapPlayerIcon = trap_R_RegisterShader( "gfx/menus/rmg/arrow_w" );
  995.  
  996.     CG_LoadingStage ( 7 );
  997.  
  998.     Com_Printf( S_COLOR_CYAN "---------- Fx System Initialization ---------\n" );
  999.     trap_FX_InitSystem( &cg.refdef);
  1000.  
  1001.     Com_Printf( S_COLOR_CYAN "----- Fx System Initialization Complete -----\n" );
  1002.     CG_RegisterEffects();
  1003.  
  1004.     // Initialize the materials
  1005.     trap_MAT_Init();
  1006.  
  1007.     CG_LoadingStage ( 8 );
  1008.  
  1009.     // Initialize the crosshairs
  1010.     for ( i = 0 ; i < NUM_CROSSHAIRS ; i++ ) 
  1011.     {
  1012.         cgs.media.crosshairShader[i] = trap_R_RegisterShader( va("gfx/menus/crosshairs/ch%i", i) );
  1013.     }
  1014.  
  1015.     CG_LoadingStage ( 9 );
  1016.  
  1017.     if ( cgs.gametypeData->teams ) 
  1018.     {
  1019.         cgs.media.blueFriendShader = trap_R_RegisterShader ( "gfx/menus/hud/team_blue" );
  1020.         cgs.media.redFriendShader  = trap_R_RegisterShader ( "gfx/menus/hud/team_red" );
  1021.         cgs.media.radarShader       = trap_R_RegisterShaderNoMip ( "gfx/menus/hud/radar.png" );
  1022.     }
  1023.  
  1024.     cgs.media.botSmallShader = trap_R_RegisterShaderNoMip ( "gfx/menus/hud/bot_small" );
  1025.     cgs.media.armorShader     = trap_R_RegisterShaderNoMip ( "gfx/menus/hud/hud_armor" );
  1026.     cgs.media.deadShader     = trap_R_RegisterShaderNoMip ( "gfx/menus/hud/dead" );
  1027.  
  1028.     CG_LoadingStage ( 10 );
  1029.  
  1030.     // Initialize weapons, load them all 
  1031.     memset( cg_weapons, 0, sizeof( cg_weapons ) );
  1032.  
  1033.     for (i = WP_NONE + 1; i < WP_NUM_WEAPONS; i ++ )
  1034.     {
  1035.         if ( cgs.pickupsDisabled && !BG_IsWeaponAvailableForOutfitting ( i, 2 ) )
  1036.         {
  1037.             continue;
  1038.         }
  1039.  
  1040.         CG_RegisterWeapon ( i );
  1041.     }
  1042.  
  1043.     CG_LoadingStage ( 11 );
  1044.  
  1045.     // only register the items that the server says we need
  1046.     strcpy( items, CG_ConfigString( CS_ITEMS) );
  1047.  
  1048.     for ( i = 1 ; i < bg_numItems ; i++ ) 
  1049.     {
  1050.         // Dont bother with weapons, theyare already loaded
  1051.  
  1052.         if ( items[ i ] == '1' || cg_buildScript.integer ) 
  1053.         {
  1054.             CG_RegisterItemVisuals( i );
  1055.         }
  1056.     }
  1057.  
  1058.     CG_LoadingStage ( 12 );
  1059.  
  1060.     // wall marks
  1061.     cgs.media.burnMarkShader    = trap_R_RegisterShader( "gfx/damage/burnmark5" );
  1062.     cgs.media.shadowMarkShader    = trap_R_RegisterShader( "markShadow" );
  1063.     cgs.media.wakeMarkShader    = trap_R_RegisterShader( "wake" );
  1064.     cgs.media.bloodMarkShader    = trap_R_RegisterShader( "bloodMark" );
  1065.     cgs.media.mAutomap            = 0;
  1066.  
  1067.     // register the inline models
  1068.     breakPoint = cgs.numInlineModels = trap_CM_NumInlineModels();
  1069.     for ( i = 0 ; i < cgs.numInlineModels ; i++ ) 
  1070.     {
  1071.         char    name[10];
  1072.         vec3_t    mins;
  1073.         vec3_t    maxs;
  1074.         int        j;
  1075.  
  1076.         Com_sprintf( name, sizeof(name), "*%i", i );
  1077.         cgs.inlineDrawModel[i] = trap_R_RegisterModel( name );
  1078.         if (!cgs.inlineDrawModel[i])
  1079.         {
  1080.             breakPoint = i;
  1081.             break;
  1082.         }
  1083.  
  1084.         trap_R_ModelBounds( cgs.inlineDrawModel[i], mins, maxs );
  1085.         for ( j = 0 ; j < 3 ; j++ ) 
  1086.         {
  1087.             cgs.inlineModelMidpoints[i][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
  1088.         }
  1089.     }
  1090.  
  1091.     // register all the server specified models
  1092.     for (i=1 ; i<MAX_MODELS ; i++) 
  1093.     {
  1094.         const char    *modelName;
  1095.  
  1096.         modelName = CG_ConfigString( CS_MODELS+i );
  1097.         if ( !modelName[0] ) 
  1098.         {
  1099.             break;
  1100.         }
  1101.         cgs.gameModels[i] = trap_R_RegisterModel( modelName );
  1102.     }
  1103.  
  1104.     // register all the server specified icons
  1105.     for ( i = 1; i < MAX_ICONS; i ++ )
  1106.     {
  1107.         const char* iconName;
  1108.  
  1109.         iconName = CG_ConfigString ( CS_ICONS + i );
  1110.         if ( !iconName[0] )
  1111.         {
  1112.             break;
  1113.         }
  1114.  
  1115.         cgs.gameIcons[i] = trap_R_RegisterShaderNoMip ( iconName );
  1116.     }
  1117.  
  1118.     CG_LoadingString( "BSP instances" );
  1119.  
  1120.     for(i = 1; i < MAX_SUB_BSP; i++)
  1121.     {
  1122.         const char        *bspName = 0;
  1123.         vec3_t            mins, maxs;
  1124.         int                j;
  1125.  
  1126.         bspName = CG_ConfigString( CS_BSP_MODELS+i );
  1127.         if ( !bspName[0] ) 
  1128.         {
  1129.             break;
  1130.         }
  1131.  
  1132.         trap_CM_LoadMap( bspName, qtrue );
  1133.         cgs.inlineDrawModel[breakPoint] = trap_R_RegisterModel( bspName );
  1134.         trap_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
  1135.         for ( j = 0 ; j < 3 ; j++ ) 
  1136.         {
  1137.             cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
  1138.         }
  1139.         breakPoint++;
  1140.         for(sub=1;sub<MAX_MODELS;sub++)
  1141.         {
  1142.             Com_sprintf(temp, MAX_QPATH, "*%d-%d", i, sub);
  1143.             cgs.inlineDrawModel[breakPoint] = trap_R_RegisterModel( temp );
  1144.             if (!cgs.inlineDrawModel[breakPoint])
  1145.             {
  1146.                 break;
  1147.             }
  1148.             trap_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
  1149.             for ( j = 0 ; j < 3 ; j++ ) 
  1150.             {
  1151.                 cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
  1152.             }
  1153.             breakPoint++;
  1154.         }
  1155.     }
  1156.  
  1157. //    cg.mInRMG = qfalse;
  1158.  
  1159.     // Register  all the terrain ents
  1160.     CG_LoadingString( "Creating terrain" );
  1161.     for(i = 1; i < MAX_TERRAINS; i++)
  1162.     {
  1163.         terrainInfo = CG_ConfigString( CS_TERRAINS + i );
  1164.         if ( !terrainInfo[0] )
  1165.         {
  1166.             break;
  1167.         }
  1168.  
  1169.         terrainID = trap_CM_RegisterTerrain(terrainInfo);
  1170. /*
  1171.         if (i == 1)
  1172.         {
  1173.             cg.mInRMG = qtrue;
  1174.         }
  1175. */
  1176.  
  1177.         trap_RMG_Init(terrainID, terrainInfo);
  1178.  
  1179.         // Send off the terrainInfo to the renderer
  1180.         trap_RE_InitRendererTerrain( terrainInfo );
  1181.     }
  1182.  
  1183.     if (cg.mInRMG)
  1184.     {
  1185.         const char* info;
  1186.  
  1187.         trap_CM_TM_Upload(0, 0);        // do not draw the origin / angles on the map itself
  1188.         cgs.media.mAutomap = trap_R_RegisterShader( "gfx/menus/rmg/automap" );
  1189.  
  1190.         cgs.mIRDist = RMG_distancecull.integer;
  1191.  
  1192.         info = CG_ConfigString ( CS_SYSTEMINFO );
  1193.         trap_Cvar_Set ( "ui_about_seed", Info_ValueForKey ( info,"RMG_textseed" ) );
  1194.     }
  1195.     else
  1196.     {
  1197.         trap_R_ModelBounds( cgs.inlineDrawModel[0], cgs.mWorldMins, cgs.mWorldMaxs );
  1198.         VectorSubtract(cgs.mWorldMaxs, cgs.mWorldMins, distance);
  1199.         cgs.mIRDist = VectorLength(distance);
  1200. //        cgs.mIRSeeThrough = cgs.mIRDist / 2.0;
  1201.     }
  1202.     cgs.mIRDist = 2500.0;
  1203.     cgs.mIRSeeThrough = 150.0;
  1204.  
  1205.     CG_LoadingString("skins");
  1206.  
  1207.     cgs.media.damageDirShader = trap_R_RegisterShader("gfx/misc/hit_direction_final");
  1208.     cgs.media.glassChunkEffect = trap_FX_RegisterEffect ( "chunks/debris_glass.efx" );
  1209.  
  1210.     cgs.media.playerFleshImpactEffect = trap_FX_RegisterEffect ( "blood_squirt_mp.efx" );
  1211.     cgs.media.mBloodSmall = trap_FX_RegisterEffect ( "impact_player_mp.efx" );
  1212.  
  1213.     cgs.media.test = trap_FX_RegisterEffect ( "arterial_squirt_small.efx" );
  1214.  
  1215.     trap_G2API_InitGhoul2Model ( &cgs.media.nightVisionModel, "models/characters/bolt_ons/nightvision_bolt_on.glm", 0, 0, 0, 0, 0 );
  1216.  
  1217.     CG_LoadingStage ( 13 );
  1218. }
  1219.  
  1220. /*                                                                                                                                            
  1221. ===================
  1222. CG_RegisterClients
  1223. ===================
  1224. */
  1225. static void CG_RegisterClients( void ) 
  1226. {
  1227.     int        i;
  1228.  
  1229.     CG_LoadingClient(cg.clientNum);
  1230.     CG_NewClientInfo(cg.clientNum);
  1231.  
  1232.     for (i=0 ; i<MAX_CLIENTS ; i++) 
  1233.     {
  1234.         const char        *clientInfo;
  1235.  
  1236.         if (cg.clientNum == i) 
  1237.         {
  1238.             continue;
  1239.         }
  1240.  
  1241.         clientInfo = CG_ConfigString( CS_PLAYERS+i );
  1242.         
  1243.         if ( !clientInfo[0]) 
  1244.         {
  1245.             continue;
  1246.         }
  1247.         
  1248.         CG_LoadingClient( i );
  1249.         CG_NewClientInfo( i );
  1250.     }
  1251. }
  1252.  
  1253. //===========================================================================
  1254.  
  1255. /*
  1256. =================
  1257. CG_ConfigString
  1258. =================
  1259. */
  1260. const char *CG_ConfigString( int index ) 
  1261. {
  1262.     if ( index < 0 || index >= MAX_CONFIGSTRINGS ) 
  1263.     {
  1264.         Com_Error( ERR_FATAL, "CG_ConfigString: bad index: %i", index );
  1265.     }
  1266.  
  1267.     return cgs.gameState.stringData + cgs.gameState.stringOffsets[ index ];
  1268. }
  1269.  
  1270. //==================================================================
  1271.  
  1272. /*
  1273. ======================
  1274. CG_StartMusic
  1275.  
  1276. ======================
  1277. */
  1278. void CG_StartMusic( qboolean bForceStart ) 
  1279. {
  1280.     const char    *s;
  1281.     char        parm1[MAX_QPATH], parm2[MAX_QPATH];
  1282.  
  1283.     // start the background music
  1284.     s = (char *)CG_ConfigString( CS_MUSIC );
  1285.     Q_strncpyz( parm1, COM_Parse( &s ), sizeof( parm1 ) );
  1286.     Q_strncpyz( parm2, COM_Parse( &s ), sizeof( parm2 ) );
  1287.  
  1288.     if (!parm2[0])
  1289.     {
  1290.         strcpy(parm2, parm1);
  1291.     }
  1292.     if ( *parm1 && *parm2 )
  1293.     {
  1294.         trap_S_StartBackgroundTrack( parm1, parm2, !bForceStart );
  1295.     }
  1296. }
  1297.  
  1298. char *CG_GetMenuBuffer(const char *filename) 
  1299. {
  1300.     int    len;
  1301.     fileHandle_t    f;
  1302.     static char buf[MAX_MENUFILE];
  1303.  
  1304.     len = trap_FS_FOpenFile( filename, &f, FS_READ );
  1305.     if ( !f ) {
  1306.         trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", filename ) );
  1307.         return NULL;
  1308.     }
  1309.     if ( len >= MAX_MENUFILE ) {
  1310.         trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", filename, len, MAX_MENUFILE ) );
  1311.         trap_FS_FCloseFile( f );
  1312.         return NULL;
  1313.     }
  1314.  
  1315.     trap_FS_Read( buf, len, f );
  1316.     buf[len] = 0;
  1317.     trap_FS_FCloseFile( f );
  1318.  
  1319.     return buf;
  1320. }
  1321.  
  1322. //
  1323. // ==============================
  1324. // new hud stuff ( mission pack )
  1325. // ==============================
  1326. //
  1327. qboolean CG_Asset_Parse(int handle) {
  1328.     pc_token_t token;
  1329.     const char *tempStr;
  1330.  
  1331.     if (!trap_PC_ReadToken(handle, &token))
  1332.         return qfalse;
  1333.     if (Q_stricmp(token.string, "{") != 0) {
  1334.         return qfalse;
  1335.     }
  1336.     
  1337.     while ( 1 ) 
  1338.     {
  1339.         if (!trap_PC_ReadToken(handle, &token))
  1340.             return qfalse;
  1341.  
  1342.         if (Q_stricmp(token.string, "}") == 0) 
  1343.         {
  1344.             return qtrue;
  1345.         }
  1346.  
  1347.         // font
  1348.         if (Q_stricmp(token.string, "defaultFont") == 0) 
  1349.         {
  1350.             if (!PC_String_Parse(handle, &tempStr) ) 
  1351.             {
  1352.                 return qfalse;
  1353.             }
  1354.             cgDC.Assets.defaultFont = cgDC.registerFont(tempStr);
  1355.             continue;
  1356.         }
  1357.  
  1358.         // itemFocusSound
  1359.         if (Q_stricmp(token.string, "itemFocusSound") == 0) 
  1360.         {
  1361.             if (!PC_String_Parse(handle, &tempStr)) 
  1362.             {
  1363.                 return qfalse;
  1364.             }
  1365.             cgDC.Assets.itemFocusSound = trap_S_RegisterSound( tempStr );
  1366.             continue;
  1367.         }
  1368.  
  1369.         if (Q_stricmp(token.string, "cursor") == 0) {
  1370.             if (!PC_String_Parse(handle, &cgDC.Assets.cursorStr)) {
  1371.                 return qfalse;
  1372.             }
  1373.             cgDC.Assets.cursor = trap_R_RegisterShaderNoMip( cgDC.Assets.cursorStr);
  1374.             continue;
  1375.         }
  1376.  
  1377.         if (Q_stricmp(token.string, "fadeClamp") == 0) {
  1378.             if (!PC_Float_Parse(handle, &cgDC.Assets.fadeClamp)) {
  1379.                 return qfalse;
  1380.             }
  1381.             continue;
  1382.         }
  1383.  
  1384.         if (Q_stricmp(token.string, "fadeCycle") == 0) {
  1385.             if (!PC_Int_Parse(handle, &cgDC.Assets.fadeCycle)) {
  1386.                 return qfalse;
  1387.             }
  1388.             continue;
  1389.         }
  1390.  
  1391.         if (Q_stricmp(token.string, "fadeAmount") == 0) {
  1392.             if (!PC_Float_Parse(handle, &cgDC.Assets.fadeAmount)) {
  1393.                 return qfalse;
  1394.             }
  1395.             continue;
  1396.         }
  1397.  
  1398.         if (Q_stricmp(token.string, "shadowX") == 0) {
  1399.             if (!PC_Float_Parse(handle, &cgDC.Assets.shadowX)) {
  1400.                 return qfalse;
  1401.             }
  1402.             continue;
  1403.         }
  1404.  
  1405.         if (Q_stricmp(token.string, "shadowY") == 0) {
  1406.             if (!PC_Float_Parse(handle, &cgDC.Assets.shadowY)) {
  1407.                 return qfalse;
  1408.             }
  1409.             continue;
  1410.         }
  1411.  
  1412.         if (Q_stricmp(token.string, "shader") == 0) 
  1413.         {
  1414.             if (!PC_String_Parse(handle, &tempStr)) 
  1415.             {
  1416.                 return qfalse;
  1417.             }
  1418.             trap_R_RegisterShaderNoMip ( tempStr );
  1419.             continue;
  1420.         }
  1421.  
  1422.         if (Q_stricmp(token.string, "shadowColor") == 0) {
  1423.             if (!PC_Color_Parse(handle, &cgDC.Assets.shadowColor)) {
  1424.                 return qfalse;
  1425.             }
  1426.             cgDC.Assets.shadowFadeClamp = cgDC.Assets.shadowColor[3];
  1427.             continue;
  1428.         }
  1429.     }
  1430.     return qfalse; // bk001204 - why not?
  1431. }
  1432.  
  1433. /*
  1434. ======================
  1435. CG_ParseMenu
  1436. ======================
  1437. */
  1438. void CG_ParseMenu ( const char *menuFile )
  1439. {
  1440.     pc_token_t    token;
  1441.     int            handle;
  1442.  
  1443.     // Load the menu file
  1444.     handle = trap_PC_LoadSource(menuFile);
  1445.     if (!handle)
  1446.     {
  1447.         return;
  1448.     }
  1449.  
  1450.     while ( 1 ) 
  1451.     {
  1452.         if (!trap_PC_ReadToken( handle, &token )) 
  1453.         {
  1454.             break;
  1455.         }
  1456.  
  1457.         if ( token.string[0] == '}' ) 
  1458.         {
  1459.             break;
  1460.         }
  1461.  
  1462.         if (Q_stricmp(token.string, "assetGlobalDef") == 0) 
  1463.         {
  1464.             if (CG_Asset_Parse(handle)) 
  1465.             {
  1466.                 continue;
  1467.             } 
  1468.             else 
  1469.             {
  1470.                 break;
  1471.             }
  1472.         }
  1473.  
  1474.         if (Q_stricmp(token.string, "menudef") == 0) 
  1475.         {
  1476.             // start a new menu
  1477.             Menu_New ( handle );
  1478.         }
  1479.     }
  1480.  
  1481.     trap_PC_FreeSource(handle);
  1482. }
  1483.  
  1484. /*
  1485. ======================
  1486. CG_LoadMenu
  1487. ======================
  1488. */
  1489. qboolean CG_LoadMenu ( const char **p ) 
  1490. {
  1491.     char *token;
  1492.  
  1493.     token = COM_ParseExt(p, qtrue);
  1494.  
  1495.     if (token[0] != '{') 
  1496.     {
  1497.         return qfalse;
  1498.     }
  1499.  
  1500.     while ( 1 ) 
  1501.     {
  1502.         token = COM_ParseExt(p, qtrue);
  1503.     
  1504.         if (Q_stricmp(token, "}") == 0) 
  1505.         {
  1506.             return qtrue;
  1507.         }
  1508.  
  1509.         if ( !token || token[0] == 0 ) 
  1510.         {
  1511.             return qfalse;
  1512.         }
  1513.  
  1514.         CG_ParseMenu(token); 
  1515.     }
  1516.  
  1517.     return qfalse;
  1518. }
  1519.  
  1520. /*
  1521. ======================
  1522. CG_LoadMenus
  1523. ======================
  1524. */
  1525. void CG_LoadMenus ( const char *menuFile ) 
  1526. {
  1527.     char            *token;
  1528.     const char        *p;
  1529.     int                len, start;
  1530.     fileHandle_t    f;
  1531.     static char        buf[MAX_MENUDEFFILE];
  1532.  
  1533.     start = trap_Milliseconds();
  1534.  
  1535.     trap_PC_LoadGlobalDefines ( "ui/menudef.h" );
  1536.  
  1537.     // Open the hud menu file
  1538.     len = trap_FS_FOpenFile( menuFile, &f, FS_READ );
  1539.     if ( !f ) 
  1540.     {
  1541.         Com_Error( ERR_FATAL, va( S_COLOR_RED "hud menu file not found: ui/hud.txt, unable to continue!\n", menuFile ) );
  1542.         return;
  1543.     }
  1544.  
  1545.     // Too big?
  1546.     if ( len >= MAX_MENUDEFFILE ) 
  1547.     {
  1548.         Com_Error( ERR_FATAL, va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", menuFile, len, MAX_MENUDEFFILE ) );
  1549.         trap_FS_FCloseFile( f );
  1550.         return;
  1551.     }
  1552.  
  1553.     trap_FS_Read( buf, len, f );
  1554.     buf[len] = 0;
  1555.     trap_FS_FCloseFile( f );
  1556.     
  1557.     COM_Compress(buf);
  1558.  
  1559.     Menu_Reset();
  1560.  
  1561.     p = buf;
  1562.  
  1563.     while ( 1 ) 
  1564.     {
  1565.         token = COM_ParseExt( &p, qtrue );
  1566.         if( !token || token[0] == 0 || token[0] == '}') 
  1567.         {
  1568.             break;
  1569.         }
  1570.  
  1571.         if ( Q_stricmp( token, "}" ) == 0 ) 
  1572.         {
  1573.             break;
  1574.         }
  1575.  
  1576.         if (Q_stricmp(token, "loadmenu") == 0) 
  1577.         {
  1578.             if ( CG_LoadMenu ( &p ) ) 
  1579.             {
  1580.                 continue;
  1581.             } 
  1582.             else 
  1583.             {
  1584.                 break;
  1585.             }
  1586.         }
  1587.     }
  1588.  
  1589.     trap_PC_RemoveAllGlobalDefines ( );
  1590.  
  1591.     Com_Printf("HUD menu load time = %d milli seconds\n", trap_Milliseconds() - start);
  1592. }
  1593.  
  1594. /*
  1595. ======================
  1596. CG_LoadMenus
  1597. ======================
  1598. */
  1599. static qboolean CG_OwnerDrawHandleKey(int ownerDraw, int flags, float *special, int key, const char* param ) 
  1600. {
  1601.     return qfalse;
  1602. }
  1603.  
  1604.  
  1605. static int CG_FeederCount(float feederID) 
  1606. {
  1607.     return 0;
  1608. }
  1609.  
  1610. static const char *CG_FeederItemText ( float feederID, int index, int column, qhandle_t *handle) 
  1611. {
  1612.     return "";
  1613. }
  1614.  
  1615. static qhandle_t CG_FeederItemImage(float feederID, int index) 
  1616. {
  1617.     return 0;
  1618. }
  1619.  
  1620. static void CG_FeederSelection(float feederID, int index) 
  1621. {
  1622. }
  1623.  
  1624. static float CG_Cvar_Get(const char *cvar) 
  1625. {
  1626.     char buff[128];
  1627.     memset(buff, 0, sizeof(buff));
  1628.     trap_Cvar_VariableStringBuffer(cvar, buff, sizeof(buff));
  1629.  
  1630.     return atof(buff);
  1631. }
  1632.  
  1633. static int CG_OwnerDrawWidth(int ownerDraw, qhandle_t font, float scale ) 
  1634. {
  1635.     switch (ownerDraw) 
  1636.     {
  1637.         case CG_GAME_TYPE:
  1638.             return trap_R_GetTextWidth (CG_GameTypeString(), font, scale, 0 );
  1639.  
  1640.         case CG_GAME_STATUS:
  1641.             return trap_R_GetTextWidth (CG_GetGameStatusText(), font, scale, 0 );
  1642.     }
  1643.  
  1644.     return 0;
  1645. }
  1646.  
  1647. static int CG_PlayCinematic(const char *name, float x, float y, float w, float h) {
  1648.   return trap_CIN_PlayCinematic(name, x, y, w, h, CIN_loop);
  1649. }
  1650.  
  1651. static void CG_StopCinematic(int handle) {
  1652.   trap_CIN_StopCinematic(handle);
  1653. }
  1654.  
  1655. static void CG_DrawCinematic(int handle, float x, float y, float w, float h) {
  1656.   trap_CIN_SetExtents(handle, x, y, w, h);
  1657.   trap_CIN_DrawCinematic(handle);
  1658. }
  1659.  
  1660. static void CG_RunCinematicFrame(int handle) {
  1661.   trap_CIN_RunCinematic(handle);
  1662. }
  1663.  
  1664. /*
  1665. =================
  1666. CG_LoadHudMenu
  1667. =================
  1668. */
  1669. void CG_LoadHudMenu() 
  1670. {
  1671.     cgDC.registerShaderNoMip    = &trap_R_RegisterShaderNoMip;
  1672.     cgDC.setColor                = &trap_R_SetColor;
  1673.     cgDC.drawHandlePic            = &CG_DrawPic;
  1674.     cgDC.drawStretchPic            = &trap_R_DrawStretchPic;
  1675.     cgDC.drawText                = &CG_DrawText;
  1676.     cgDC.drawTextWithCursor        = &CG_DrawTextWithCursor;
  1677.     cgDC.getTextWidth            = &trap_R_GetTextWidth;
  1678.     cgDC.getTextHeight            = &trap_R_GetTextHeight;
  1679.     cgDC.registerModel            = &trap_R_RegisterModel;
  1680.     cgDC.modelBounds            = &trap_R_ModelBounds;
  1681.     cgDC.fillRect                = &CG_FillRect;
  1682.     cgDC.drawRect                = &CG_DrawRect;   
  1683.     cgDC.drawSides                = &CG_DrawSides;
  1684.     cgDC.drawTopBottom            = &CG_DrawTopBottom;
  1685.     cgDC.clearScene                = &trap_R_ClearScene;
  1686.     cgDC.addRefEntityToScene    = &trap_R_AddRefEntityToScene;
  1687.     cgDC.renderScene            = &trap_R_RenderScene;
  1688.     cgDC.registerFont            = &trap_R_RegisterFont;
  1689.     cgDC.ownerDrawItem            = &CG_OwnerDraw;
  1690.     cgDC.getValue                = &CG_GetValue;
  1691.     cgDC.ownerDrawVisible        = &CG_OwnerDrawVisible;
  1692.     cgDC.ownerDrawDisabled        = &CG_OwnerDrawDisabled;
  1693.     cgDC.runScript                = &CG_RunMenuScript;
  1694.     cgDC.getTeamColor            = &CG_GetTeamColor;
  1695.     cgDC.setCVar                = trap_Cvar_Set;
  1696.     cgDC.getCVarString            = trap_Cvar_VariableStringBuffer;
  1697.     cgDC.getCVarValue            = CG_Cvar_Get;
  1698.     cgDC.startLocalSound        = &trap_S_StartLocalSound;
  1699.     cgDC.ownerDrawHandleKey        = &CG_OwnerDrawHandleKey;
  1700.     cgDC.feederCount            = &CG_FeederCount;
  1701.     cgDC.feederItemImage        = &CG_FeederItemImage;
  1702.     cgDC.feederItemText            = &CG_FeederItemText;
  1703.     cgDC.feederSelection        = &CG_FeederSelection;
  1704.     cgDC.Error                    = &Com_Error; 
  1705.     cgDC.Print                    = &Com_Printf; 
  1706.     cgDC.ownerDrawWidth            = &CG_OwnerDrawWidth;
  1707.     cgDC.registerSound            = &trap_S_RegisterSound;
  1708.     cgDC.startBackgroundTrack    = &trap_S_StartBackgroundTrack;
  1709.     cgDC.stopBackgroundTrack    = &trap_S_StopBackgroundTrack;
  1710.     cgDC.playCinematic            = &CG_PlayCinematic;
  1711.     cgDC.stopCinematic            = &CG_StopCinematic;
  1712.     cgDC.drawCinematic =         &CG_DrawCinematic;
  1713.     cgDC.runCinematicFrame        = &CG_RunCinematicFrame;
  1714.  
  1715.     cgDC.yscale = cgDC.glconfig.vidHeight * (1.0/480.0);
  1716.     cgDC.xscale = cgDC.glconfig.vidWidth * (1.0/640.0);
  1717.  
  1718.     Init_Display(&cgDC);
  1719.  
  1720.     Menu_Reset();
  1721.  
  1722.     CG_LoadMenus( "ui/hud.txt" );
  1723. }
  1724.  
  1725. /*
  1726. =================
  1727. CG_AssetCache
  1728. =================
  1729. */
  1730. void CG_AssetCache() 
  1731. {
  1732.     cgDC.Assets.scrollBar            = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR );
  1733.     cgDC.Assets.scrollBarArrowDown    = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWDOWN );
  1734.     cgDC.Assets.scrollBarArrowUp    = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWUP );
  1735.     cgDC.Assets.scrollBarArrowLeft    = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWLEFT );
  1736.     cgDC.Assets.scrollBarArrowRight = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWRIGHT );
  1737.     cgDC.Assets.scrollBarThumb        = trap_R_RegisterShaderNoMip( ASSET_SCROLL_THUMB );
  1738.     cgDC.Assets.sliderBar            = trap_R_RegisterShaderNoMip( ASSET_SLIDER_BAR );
  1739.     cgDC.Assets.sliderThumb            = trap_R_RegisterShaderNoMip( ASSET_SLIDER_THUMB );
  1740. }
  1741.  
  1742. // initialise the cg_entities structure - take into account the ghoul2 stl stuff in the active snap shots
  1743. void CG_Init_CG(void)
  1744. {
  1745.     memset( &cg, 0, sizeof(cg));
  1746. }
  1747.  
  1748. // initialise the cg_entities structure - take into account the ghoul2 stl stuff
  1749. void CG_Init_CGents(void)
  1750. {
  1751.     memset(&cg_entities, 0, sizeof(cg_entities));
  1752. }
  1753.  
  1754. void CG_InitItems(void)
  1755. {
  1756.     memset( cg_items, 0, sizeof( cg_items ) );
  1757. }
  1758.  
  1759. void CG_TransitionPermanent(void)
  1760. {
  1761.     centity_t    *cent = cg_entities;
  1762.     int            i;
  1763.  
  1764.     cg_numpermanents = 0;
  1765.     for(i=0;i<MAX_GENTITIES;i++,cent++)
  1766.     {
  1767.         if (trap_GetDefaultState(i, ¢->currentState))
  1768.         {
  1769.             cent->nextState = cent->currentState;
  1770.             VectorCopy (cent->currentState.origin, cent->lerpOrigin);
  1771.             VectorCopy (cent->currentState.angles, cent->lerpAngles);
  1772.             cent->currentValid = qtrue;
  1773.  
  1774.             cg_permanents[cg_numpermanents++] = cent;
  1775.         }
  1776.     }
  1777. }
  1778.  
  1779. /*
  1780. =================
  1781. CG_Init
  1782.  
  1783. Called after every level change or subsystem restart
  1784. Will perform callbacks to make the loading info screen update.
  1785. =================
  1786. */
  1787. void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum ) 
  1788. {
  1789.     const char    *s;
  1790.  
  1791.     // Some of the new SOF2 features required more traffic through 
  1792.     // the trap calls than than the original vm code would allow for.  Therefore
  1793.     // a block of shared memory is registered with the engine to allow for
  1794.     // larger pieced of data to be transferred back and forth.
  1795.     trap_CG_RegisterSharedMemory(cg.sharedBuffer);
  1796.  
  1797.     // clear everything
  1798.     CG_Init_CGents();
  1799.     CG_Init_CG();
  1800.     CG_InitItems();
  1801.  
  1802.     BG_ParseNPCFiles ( );
  1803.  
  1804.     memset( &cgs, 0, sizeof( cgs ) );
  1805.     memset( cg_weapons, 0, sizeof(cg_weapons) );
  1806.  
  1807.     // Load these first since they are used to display the status
  1808.     cgs.media.loadBulletShader    = trap_R_RegisterShaderNoMip ( "gfx/menus/misc/load_bullet.tga" );
  1809.     cgs.media.loadClipShader    = trap_R_RegisterShaderNoMip ( "gfx/menus/misc/load_clip.tga" );
  1810.     cgs.media.whiteShader        = trap_R_RegisterShaderNoMip ( "white" );
  1811.  
  1812.     cg.clientNum = clientNum;
  1813.  
  1814.     cgs.processedSnapshotNum = serverMessageNum;
  1815.     cgs.serverCommandSequence = serverCommandSequence;
  1816.  
  1817.     CG_LoadingStage ( 0 );
  1818.  
  1819.     CG_RegisterCvars();
  1820.  
  1821.     CG_InitConsoleCommands();
  1822.  
  1823.     // Populate the gametypeData array with the gametypes available
  1824.     // in the scripts directory
  1825.     BG_BuildGametypeList();
  1826.  
  1827.     cg.weaponSelect = WP_USSOCOM_PISTOL;
  1828.  
  1829.     // get the rendering configuration from the client system
  1830.     trap_GetGlconfig( &cgs.glconfig );
  1831.     cgs.screenXScale = cgs.glconfig.vidWidth / 640.0;
  1832.     cgs.screenYScale = cgs.glconfig.vidHeight / 480.0;
  1833.  
  1834.     // Register the fonts
  1835.     cgs.media.hudFont = trap_R_RegisterFont ( "hud" );
  1836.     cgs.media.lcdFont = trap_R_RegisterFont ( "lcdsmall" );
  1837.  
  1838.     // Load the user interface
  1839.     String_Init();
  1840.     CG_AssetCache();
  1841.     CG_LoadHudMenu();
  1842.  
  1843.     // get the gamestate from the client system
  1844.     trap_GetGameState( &cgs.gameState );
  1845.  
  1846.     CG_TransitionPermanent();
  1847.  
  1848.     // check version
  1849.     s = CG_ConfigString( CS_GAME_VERSION );
  1850.     if ( strcmp( s, GAME_VERSION ) ) 
  1851.     {
  1852.         Com_Error( ERR_FATAL, "Client/Server game mismatch: %s/%s", GAME_VERSION, s );
  1853.     }
  1854.  
  1855.     s = CG_ConfigString( CS_LEVEL_START_TIME );
  1856.     cgs.levelStartTime = atoi( s );
  1857.     
  1858.     CG_ParseServerinfo();
  1859.  
  1860.     CG_ParseGametypeFile ( );
  1861.  
  1862.     // load the new map
  1863.     CG_LoadingString( "collision map" );
  1864.  
  1865.     CG_LoadingStage ( 1 );
  1866.  
  1867.     trap_CM_LoadMap( cgs.mapname, qfalse );
  1868.  
  1869.     // Make sure we have update values (scores)
  1870.     CG_SetConfigValues();
  1871.  
  1872.     CG_LoadingStage ( 2 );
  1873.  
  1874.     // force players to load instead of defer
  1875.     cg.loading = qtrue;        
  1876.  
  1877.     CG_LoadingString( "sounds" );
  1878.  
  1879.     CG_RegisterLadders ( );
  1880.     CG_RegisterSounds();
  1881.     CG_InitHitModel( );
  1882.  
  1883.     CG_LoadingString( "graphics" );
  1884.     BG_ParseInviewFile ( cgs.pickupsDisabled );
  1885.     CG_RegisterGraphics ( );
  1886.  
  1887. //    CG_RegisterMission ( );
  1888.  
  1889.     CG_ParseGore();
  1890.  
  1891.     CG_LoadingString( "clients" );
  1892.  
  1893.     CG_RegisterClients();        // if low on memory, some clients will be deferred
  1894.  
  1895.     CG_LoadingStage ( 14 );
  1896.  
  1897.     CG_InitLocalEntities();
  1898.  
  1899.     CG_LoadingStage ( 15 );
  1900.  
  1901.     CG_StartMusic(qfalse);
  1902.  
  1903.     CG_LoadingString( "Clearing light styles" );
  1904.     CG_ClearLightStyles();
  1905.  
  1906.     CG_LoadingString( "" );
  1907.  
  1908.     CG_ShaderStateChanged();
  1909.  
  1910.     trap_S_ClearLoopingSounds( qtrue );
  1911.  
  1912.     // In a mission game we want to bring up the objective screen on initial connection
  1913.     if ( cgs.gametypeData->description || cgs.pickupsDisabled || cgs.gametypeData->teams  )
  1914.     {
  1915.         cg.popupObjectives = qtrue;
  1916.     }
  1917.  
  1918.     trap_Cvar_Set ( "ui_info_gametype", va("%i",cgs.gametype ) );
  1919.     trap_Cvar_Set ( "ui_info_objectives", cgs.gametypeData->description );
  1920.     trap_Cvar_Set ( "con_draw", cg.scoreBoardShowing?"0":"1" );
  1921.  
  1922.     // remove the last loading update
  1923.     cg.infoScreenText[0] = 0;
  1924.  
  1925.     cg.loading = qfalse;    // future players will be deferred
  1926. }
  1927.  
  1928. void CG_ShutdownG2Models(void)
  1929. {
  1930.     int                i, j;
  1931.     clientInfo_t    *ci;
  1932.  
  1933.     for(i=0;i<MAX_ITEMS;i++)
  1934.     {
  1935.         for(j=0;j<MAX_ITEM_MODELS;j++)
  1936.         {
  1937.             if (cg_items[i].g2Models[j])
  1938.             {
  1939.                 trap_G2API_CleanGhoul2Models(&cg_items[i].g2Models[j]);
  1940.             }
  1941.         }
  1942.     }
  1943.  
  1944.     for(i=0;i<MAX_GENTITIES;i++)
  1945.     {
  1946.         if (cg_entities[i].ghoul2)
  1947.         {
  1948.             trap_G2API_CleanGhoul2Models(&cg_entities[i].ghoul2);
  1949.         }
  1950.     }
  1951.  
  1952.     for(i=0;i<MAX_CLIENTS;i++)
  1953.     {
  1954.         ci = &cgs.clientinfo[i];
  1955.         if (ci->ghoul2Model)
  1956.         {
  1957.             trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
  1958.         }
  1959.     }
  1960. }
  1961.  
  1962. void CG_ShutdownGore(void);
  1963.  
  1964. /*
  1965. =================
  1966. CG_Shutdown
  1967.  
  1968. Called before every level change or subsystem restart
  1969. =================
  1970. */
  1971. void CG_Shutdown( void ) 
  1972. {
  1973.     trap_FX_FreeSystem();
  1974.  
  1975.     CG_ShutDownWeapons();
  1976.     CG_ShutdownG2Models();
  1977.  
  1978.     CG_ShutdownGore();
  1979.  
  1980.     // some mods may need to do cleanup work here,
  1981.     // like closing files or archiving session data
  1982. }
  1983.